Micron Document
██████╗ ███████╗████████╗██╗██████╗ ███████╗██████╗ ██╗ █████╗
██╔══██╗██╔════╝╚══██╔══╝██║██╔══██╗██╔════╝██╔══██╗██║██╔══██╗
██████╔╝█████╗ ██║ ██║██████╔╝█████╗ ██║ ██║██║███████║
██╔══██╗██╔══╝ ██║ ██║██╔═══╝ ██╔══╝ ██║ ██║██║██╔══██║
██║ ██║███████╗ ██║ ██║██║ ███████╗██████╔╝██║██║ ██║
╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚═╝ ╚══════╝╚═════╝ ╚═╝╚═╝ ╚═╝


🬧 The NomadNet Encyclopedia | Archives | Info
- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b- `b

🔍 Search

¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯

IA-64
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
top
In mwawinformatica, mwbaIA-64 (Intel Architecture-64) è un'architettura a mwbq64 bit sviluppata durante una cooperazione tra mwbgIntel e mwbwHewlett-Packard e implementata da processori come mwcaItanium e mwcqItanium 2. L'obiettivo di Itanium era di introdurre un'architettura "post-mwcgRISC", utilizzando mwcwEPIC. Per questo processore a 64 bit Microsoft ed Intel hanno scritto il sistema operativo mwdaWindows XP 64 bit Edition.

Contents

EPIC

──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

Architettura

EPIC

In un tipico design di "mweqesecuzione fuori ordine" (spesso conosciuta come mwegout-of-order), un decodificatore molto complesso esamina ogni istruzione inviata alla mwewCPU mentre attraversa la mwfapipeline e controlla quali possono essere eseguite in parallelo nelle unità di esecuzione — mwfqes., una coppia di istruzioni come mwfgA = B + C e mwfwD = F + G non si influenzano l'un l'altra, e possono quindi essere eseguite parallelamente in due diverse unità di esecuzione. L'abilità di riconoscere l'mwgainstruction level parallelism (il parallelismo a livello di istruzione) nel flusso di istruzioni è essenziale per avere buone prestazioni in una CPU moderna.

Predire quando il codice non può essere diviso in questa maniera è un compito molto complesso. In molti casi l'esecuzione di un'istruzione dipende da condizioni logiche dipendenti da altre istruzioni. Ad esempio si consideri una leggera modifica dell'esempio precedente: mwggA = B + C; IF A==5 THEN D = F + G (che indica di sommare B e C e inserire il risultato in A, e se A è uguale a cinque allora inserire in D il risultato della somma tra F e G). In questo caso il risultato del secondo calcolo è comunque indipendente dal primo, ma bisogna prima effettuare la prima operazione per poter sapere se la seconda deve essere eseguita o no.

In questi casi la CPU tipicamente "indovina" se la condizione logica è vera o falsa. In circa il 90% dei casi, il codice successivo ad un mwhaIF viene eseguito, il che suggerisce che la seconda metà dei comandi del nostro esempio possono essere fatti eseguire da un'altra unità di esecuzione. Ma prevedere il risultato sbagliato per la condizione logica può comportare cali notevoli di prestazioni, dovuti al fatto che il valore calcolato dalla seconda unità è sbagliato e la CPU deve attendere per poter calcolare il risultato dell'istruzione corretta. Gran parte dell'aumento di prestazioni delle CPU attuali è dovuto al miglioramento della logica di predizione, ma ultimamente i miglioramenti stanno rallentando. La mwhqpredizione delle diramazioni del codice (detta mwhgbranch prediction) nelle attuali CPU è corretta circa il 98% delle volte.

L'architettura IA-64 invece si affida al mwiacompilatore per questo compito. Ancor prima che il programma sia eseguito dalla CPU, il compilatore esamina il codice e fa lo stesso tipo di decisioni che altrimenti avverrebbero durante l'esecuzione sulla CPU stessa. Una volta deciso quali istruzioni possono essere eseguite in parallelo in modo efficace, le unisce in un'istruzione più grande e le scrive in questa forma nel programma — da cui il nome di mwiqvery long instruction word (VLIW).

Assegnare questo compito al compilatore invece che alla CPU ha diversi vantaggi. Prima di tutto il compilatore può impiegare molto tempo a esaminare il codice, una possibilità che il processore non ha perché deve eseguire le istruzioni il più velocemente possibile. Quindi le decisioni del compilatore possono essere considerevolmente più accurate di quelle prese dall'hardware. In secondo luogo i circuiti per la mwiwbranch prediction sono alquanto complessi, e scaricare la predizione sul compilatore riduce la complessità del processore: non deve più esaminare nulla, deve limitarsi a spezzare le istruzioni e farle eseguire parallelamente alle unità. Terzo, eseguire la predizione nel compilatore ha un costo mwjauna tantum, al contrario di quello sulla CPU, che deve essere eseguita ogni volta che viene utilizzato il programma.

Il lato negativo è che il comportamento di un programma durante l'esecuzione non è sempre ovvio nel codice usato per crearlo, e può variare considerevolmente a seconda dei dati che sta effettivamente elaborando. La logica di esecuzione mwjgout-of order di una CPU può prendere decisioni basate sui dati che effettivamente sono elaborati dal programma, e che il compilatore può solo "intuire". Questo significa che è possibile che le predizioni del compilatore siano errate più spesso rispetto a quelle che potrebbe fare un circuito logico di complessità paragonabile (o anche più semplice) posto sulla CPU. Il design VLIW si affida quindi pesantemente alle prestazioni del compilatore, pagando la semplificazione del processore con l'incremento di complessità del software.

Registri

L'architettura IA-64 include un ampio insieme di registri: 128 registri a 82 bit in mwkqvirgola mobile e a 64 bit per gli interi. Oltre a questo grande numero, IA-64 aggiunge un meccanismo di mwkgregister window controllato dal mwkwRegister Stack Engine. Il testo originiale riporta: Rather than the typical spill/fill or window mechanisms used in other processors, the Itanium can rotate in a set of new registers to accommodate for new function parameters or temporaries. Questo sistema unito alla predizione è molto efficace nell'eseguire automaticamente lo "srotolamento dei cicli" (nel gergo della programmazione "srotolare un ciclo" — mwlaunrolling a loop — vuol dire esplicitare un ciclo di istruzioni eseguite più volte elencandole tutte per esteso, il che in genere porta a un miglioramento delle prestazioni).

Set di istruzioni

L'architettura IA-64 prevede istruzioni per le operazioni su dati multimediali e per i calcoli in virgola mobile.

Mentre una tipica architettura VLIW assegna sotto istruzioni da ogni "grande istruzione" ad una certa unità di esecuzione specifica, l'Itanium supporta diverse modalità di unione delle istruzioni permettendo un miglior bilanciamento tra le modalità di esecuzione in serie e in parallelo.

Funzionalità Pre-SO e funzionalità sub-SO

Appena acceso un processore Itanium è privo di alcune funzionalità. Uno "strato di astrazione del processore" (mwmgProcessor Abstraction Layer o PAL) è integrato nel mwmwBIOS e al momento dell'avvio viene caricato nella CPU per fornire un'interfaccia di basso livello che astrae alcune istruzioni e fornisce un meccanismo per aggiornare il processore tramite un aggiornamento del BIOS.

Durante l'inizializzazione del BIOS un altro strato di codice, lo strato di astrazione di sistema (mwnqSystem Abstraction Layer o SAL) è caricato per fornire mwngAPI standard necessarie per le funzioni dipendenti dall'implementazione della piattaforma.

Al di sopra delle interfacce PAL e SAL si trova l'"mwoaExtensible Firmware Interface" (EFI), l'interfaccia per il mwoqfirmware estendibile. L'EFI non fa parte dell'architettura IA-64 ma per convenzione è necessario per tutti i sistemi IA-64. È una semplice API per l'accesso agli aspetti logici del sistema (memorizzazione, video, tastiera, ecc.) unito a un sistema di esecuzione leggero (simile al mwogDOS) che permette l'esecuzione di funzioni di amministrazione del sistema, come l'aggiornamento del BIOS, la configurazione dei dispositivi di memorizzazione, configurare un mwowboot loader.

Una volta che il mwpqsistema operativo è stato avviato alcune funzionalità di PAL, SAL ed eFI rimangono residenti in memoria e possono essere utilizzate dal sistema operativo per eseguire operazioni a basso livello e che dipendono dall'hardware sottostante.

Supporto a IA-32

Per poter supportare l'architettura mwqaIA-32, l'Itanium può entrare in una modalità a mwqq32 bit con speciali istruzioni. Le istruzioni IA-32 sono state implementate nelle unità funzionali dell'Itanium. Comunque poiché l'Itanium è progettato principalmente per la velocità sulle istruzioni mwqgEPIC, e a causa dell'impossibilità di eseguire il codice in modalità mwqwmwraout-of-order, il codice IA-32 viene eseguito con penalizzazioni di prestazioni molto pesanti se paragonate alla modalità IA-64 o ai processori mwrqPentium. Per esempio le unità di esecuzione di Itanium non impostano gli accessi multipli non allineati alla memoria. Esistono inoltre software di emulazione di IA-32 disponibili gratuitamente per sistemi operativi mwrgMicrosoft Windows e mwrwLinux che hanno prestazioni superiori di circa il 50% rispetto alla modalità di emulazione del processore. L'emulatore per Windows è disponibile presso Microsoft, l'emulatore per Linux è disponibile da alcuni rivenditori Linux come mwsaNovell.

Date le prestazioni superiori degli emulatori software, e anche se l'hardware necessario per emulare IA-32 è responsabile di meno dell'1% dei transistor di mwsgItanium 2, Intel ha rimosso l'emulazione IA-32 dalla sesta generazione di chip Itanium 2 con nome in codice mwswMontecitohttp://www.eweek.com/article2/0,1895,1913658,00.asp(attualmente siamo alla nona mwuaTukwila).

Concorrenti

Anche se altre architetture a 64 bit esistono da molto tempo, la maggior parte (mwuwAlpha, mwvaPA-RISC) è sparita dal mercato. I concorrenti di Itanium nella corsa al mercato dei server e delle mwvqworkstation sembrano essere mwvgAMD con la sua architettura mwvwAMD64, mwwaIBM con l'architettura mwwqPOWER e mwwgSun Microsystems con mwwwUltraSparc. Anche se mwxaApple avrebbe potuto rivaleggiare con Intel con la sua linea di prodotti mwxqXserve basate su mwxgPowerPC di IBM, tali prospettive sembrano impossibili dopo l'annuncio di Apple del passaggio all'architettura Intel IA-32.

In risposta alla reazione favorevole dell'industria a AMD64, la versione successiva dell'Intel mwyaXeon (mwyqNocona) supporta le estensioni mwygEM64T, che sono in larga parte compatibili con il set di istruzioni di AMD64.

Voci correlate

• mwzgItanium
• mwaaItanium 2
• mwagx86
• mwbaEM64T
• mwbgx86-64
• mwcaIA-32
• mwcgDEC Alpha

Collegamenti esterni

• mweaStoria di IA-64, su hpl.hp.com. URL consultato il 25 febbraio 2006 (archiviato dall'url originale il 4 marzo 2012).
• mweg(EN) Guida a IA-64 (PDF), su cern.ch. URL consultato il 24 dicembre 2021 (archiviato dall'url originale il 15 settembre 2009).
• mwfaIATO è un sistema che permette di analizzare ed emulare il set di istruzioni IA64